using K3Cloud.WebApi.Core.IoC.Http;
using System;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;

namespace K3Cloud.WebApi.Core.IoC.Examples;

/// <summary>
/// HTTP 连接池使用示例
/// </summary>
public static class HttpClientPoolExample
{
    /// <summary>
    /// 示例 1: 基础使用 - 自动从连接池获取 HttpClient
    /// </summary>
    public static void Example1_BasicUsage()
    {
        Console.WriteLine("========== 示例 1: 基础使用 ==========\n");

        // 从连接池获取 HttpClient（如果不存在则创建）
        var client = HttpClientFactory.CreateClient("http://k3cloud-server:8080");

        Console.WriteLine("✓ 已从连接池获取 HttpClient");
        Console.WriteLine($"  服务器地址: {client.BaseAddress}");
        Console.WriteLine($"  超时时间: {client.Timeout.TotalSeconds} 秒");
        Console.WriteLine($"  连接池状态: {HttpClientFactory.GetPoolStats()}");
    }

    /// <summary>
    /// 示例 2: 多服务器场景 - 为不同服务器维护独立连接
    /// </summary>
    public static void Example2_MultipleServers()
    {
        Console.WriteLine("\n========== 示例 2: 多服务器场景 ==========\n");

        // 为不同的服务器创建连接
        var client1 = HttpClientFactory.CreateClient("http://server1:8080");
        var client2 = HttpClientFactory.CreateClient("http://server2:8080");
        var client3 = HttpClientFactory.CreateClient("http://server3:8080");

        Console.WriteLine("✓ 已为 3 个服务器创建连接");
        Console.WriteLine($"  Server 1: {client1.BaseAddress}");
        Console.WriteLine($"  Server 2: {client2.BaseAddress}");
        Console.WriteLine($"  Server 3: {client3.BaseAddress}");
        Console.WriteLine($"  {HttpClientFactory.GetPoolStats()}");

        // 再次获取同一服务器的连接（从连接池复用）
        var client1Again = HttpClientFactory.CreateClient("http://server1:8080");
        Console.WriteLine($"\n✓ 再次获取 Server 1 连接（从连接池复用）");
        Console.WriteLine($"  是否为同一实例: {ReferenceEquals(client1, client1Again)}");
    }

    /// <summary>
    /// 示例 3: 性能对比 - 连接池 vs 每次创建新连接
    /// </summary>
    public static void Example3_PerformanceComparison()
    {
        Console.WriteLine("\n========== 示例 3: 性能对比 ==========\n");

        const int iterations = 100;
        var baseUrl = "http://test-server:8080";

        // 方式 1: 使用连接池（推荐）
        var sw1 = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            var client = HttpClientFactory.CreateClient(baseUrl);
            // 模拟使用
            _ = client.BaseAddress;
        }
        sw1.Stop();

        // 方式 2: 每次创建新的 HttpClient（不推荐）
        HttpClientFactory.EnableConnectionPool = false; // 暂时禁用连接池
        var sw2 = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            var client = HttpClientFactory.CreateClient(baseUrl + $"?v={i}"); // 不同URL避免缓存
            // 模拟使用
            _ = client.BaseAddress;
        }
        sw2.Stop();
        HttpClientFactory.EnableConnectionPool = true; // 重新启用

        Console.WriteLine($"创建 {iterations} 个 HttpClient 实例:");
        Console.WriteLine($"  使用连接池: {sw1.ElapsedMilliseconds} ms ⚡");
        Console.WriteLine($"  不使用连接池: {sw2.ElapsedMilliseconds} ms");
        Console.WriteLine($"  性能提升: {sw2.ElapsedMilliseconds / (double)sw1.ElapsedMilliseconds:F2}x");
    }

    /// <summary>
    /// 示例 4: 自定义配置
    /// </summary>
    public static void Example4_CustomConfiguration()
    {
        Console.WriteLine("\n========== 示例 4: 自定义配置 ==========\n");

        // 配置默认超时时间
        HttpClientFactory.DefaultTimeoutSeconds = 120;
        Console.WriteLine($"✓ 设置默认超时时间: {HttpClientFactory.DefaultTimeoutSeconds} 秒");

        // 为特定请求设置自定义超时
        var client = HttpClientPool.Instance.GetOrCreate(
            "http://slow-server:8080",
            TimeSpan.FromSeconds(300)
        );
        Console.WriteLine($"✓ 创建慢速服务器连接，超时时间: {client.Timeout.TotalSeconds} 秒");

        // 查看连接池状态
        Console.WriteLine($"\n{HttpClientFactory.GetPoolStats()}");
    }

    /// <summary>
    /// 示例 5: 连接池管理
    /// </summary>
    public static void Example5_PoolManagement()
    {
        Console.WriteLine("\n========== 示例 5: 连接池管理 ==========\n");

        // 创建多个连接
        for (int i = 1; i <= 3; i++)
        {
            HttpClientFactory.CreateClient($"http://server{i}:8080");
        }
        Console.WriteLine($"✓ 创建了 3 个连接");
        Console.WriteLine($"  {HttpClientFactory.GetPoolStats()}");

        // 移除特定连接
        bool removed = HttpClientPool.Instance.Remove("http://server2:8080");
        Console.WriteLine($"\n✓ 移除 server2 连接: {removed}");
        Console.WriteLine($"  {HttpClientFactory.GetPoolStats()}");

        // 清空连接池
        HttpClientFactory.ClearPool();
        Console.WriteLine($"\n✓ 清空连接池");
        Console.WriteLine($"  {HttpClientFactory.GetPoolStats()}");
    }

    /// <summary>
    /// 示例 6: 向后兼容性演示
    /// </summary>
    public static void Example6_BackwardCompatibility()
    {
        Console.WriteLine("\n========== 示例 6: 向后兼容性 ==========\n");

        // 旧代码（v1.1 及更早）：直接使用 K3CloudHelper
        Console.WriteLine("✓ v1.1 代码（自动使用连接池优化）:");
        Console.WriteLine("  var helper = new K3CloudHelper(config);");
        Console.WriteLine("  var result = await helper.QueryAsync(...);");

        // 新代码（v1.2）：完全相同，自动受益于连接池
        Console.WriteLine("\n✓ v1.2 代码（代码不变，性能提升）:");
        Console.WriteLine("  var helper = new K3CloudHelper(config);");
        Console.WriteLine("  var result = await helper.QueryAsync(...);");
        Console.WriteLine("\n  ⚡ 无需修改代码，自动优化！");

        // 如果需要禁用连接池（完全恢复旧行为）
        Console.WriteLine("\n✓ 禁用连接池（100% 恢复旧行为）:");
        Console.WriteLine("  HttpClientFactory.EnableConnectionPool = false;");
    }

    /// <summary>
    /// 运行所有示例
    /// </summary>
    public static void RunAllExamples()
    {
        Console.WriteLine("╔════════════════════════════════════════════════════════════╗");
        Console.WriteLine("║       HTTP 连接池优化 - 使用示例                           ║");
        Console.WriteLine("╚════════════════════════════════════════════════════════════╝\n");

        try
        {
            Example1_BasicUsage();
            Example2_MultipleServers();
            Example3_PerformanceComparison();
            Example4_CustomConfiguration();
            Example5_PoolManagement();
            Example6_BackwardCompatibility();

            Console.WriteLine("\n╔════════════════════════════════════════════════════════════╗");
            Console.WriteLine("║                  所有示例运行完成！                         ║");
            Console.WriteLine("╚════════════════════════════════════════════════════════════╝");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"\n❌ 示例运行出错: {ex.Message}");
        }
    }
}

/// <summary>
/// 实际使用场景示例
/// </summary>
public class RealWorldExample
{
    /// <summary>
    /// 场景 1: Web API 服务（伪代码示例）
    /// </summary>
    /// <remarks>
    /// 实际使用时，K3CloudHelper 会自动从连接池获取 HttpClient
    /// 这里只是展示概念，不需要实际编译运行
    /// </remarks>
    public class OrderApiService
    {
        // ✅ 推荐：复用服务实例，内部会自动使用连接池
        // private readonly IK3Services _k3Service;
        
        // 示例伪代码：
        // public OrderApiService(IK3Services k3Service)
        // {
        //     _k3Service = k3Service;
        //     // HttpClient 自动从连接池获取，不会泄漏
        // }

        // public async Task<string> GetOrders()
        // {
        //     // 直接使用，自动受益于连接池优化
        //     return await _k3Service.ExecuteBillQueryAsync("SAL_ORDER", "{}");
        // }
    }

    /// <summary>
    /// 场景 2: 高并发场景（概念演示）
    /// </summary>
    /// <remarks>
    /// 这是一个概念性示例，展示连接池如何帮助处理高并发
    /// 实际使用时，框架会自动管理连接池
    /// </remarks>
    public static async Task HighConcurrencyScenario()
    {
        Console.WriteLine("\n========== 高并发场景演示 ==========\n");
        Console.WriteLine("场景：模拟 1000 个并发请求");
        Console.WriteLine("\n使用连接池的优势：");
        Console.WriteLine("  ✓ 所有请求复用同一个 HttpClient");
        Console.WriteLine("  ✓ 避免端口耗尽问题");
        Console.WriteLine("  ✓ 减少 TCP 连接建立开销");
        Console.WriteLine("  ✓ 避免 TLS 握手重复执行");
        
        // 模拟创建多个客户端（实际场景中框架会自动管理）
        var sw = Stopwatch.StartNew();
        for (int i = 0; i < 1000; i++)
        {
            var client = HttpClientFactory.CreateClient("http://k3cloud-server:8080");
            await Task.Delay(0); // 模拟异步操作
        }
        sw.Stop();

        Console.WriteLine($"\n✓ 模拟完成！耗时: {sw.ElapsedMilliseconds} ms");
        Console.WriteLine($"  {HttpClientFactory.GetPoolStats()}");
        Console.WriteLine($"  ⚡ 1000 次调用，但只创建了 1 个 HttpClient 实例");
    }

    /// <summary>
    /// 场景 3: 定期清理连接池（可选）
    /// </summary>
    public static void PeriodicCleanup()
    {
        // 在长时间运行的应用中，可以定期清理连接池
        var timer = new System.Threading.Timer(_ =>
        {
            Console.WriteLine("执行定期清理...");
            HttpClientFactory.ClearPool();
            Console.WriteLine($"清理完成: {HttpClientFactory.GetPoolStats()}");
        }, null, TimeSpan.FromHours(1), TimeSpan.FromHours(1));

        Console.WriteLine("✓ 已启动定期清理任务（每小时执行一次）");
    }
}
